// 主要的 内容是关于链表的学习

function LinkedList() {
    // 内部的类： 节点类
    function Node(data) {
        this.next = null
        this.data = data
    }
    this.head = null
    this.length = 0

    // append 方法的实现
    LinkedList.prototype.append = function (ele) {
        // 1.根据新元素创建新的节点
        const newNode = new Node(ele)
        // 2判断原来的链表是否为空 
        if (this.head === null) {
            this.head = newNode
        } else {
            // 链表不为空
            // 2.1 定义自变量，保存当前找到的节点
            let current = this.head
            while (current.next) {
                current = current.next
            }
            // 2.2 找到最后一项，将其next默认为 新的  node
            current.next = newNode
        }
        // 3将总的链表长度 增加1
        this.length++
    }


    // toString方法的实现
    LinkedList.prototype.toString = function () {
        // 1、定义两个变量
        let current = this.head
        let listStr = ''
        // 2、循环获取 链表中的所有元素，并且将这些结果 添加到字符串中
        while (current) {
            listStr += current.data + " "
            current = current.next
        }
        return listStr
    }

    // insert 方法的实现
    LinkedList.prototype.insert = function (position, data) {
        // 1、对position进行越界判断
        if (position < 0 || position > this.length) return false

        // 2、根据data创建 newNode
        const newNode = new newNode(data)
        // 3、判断插入的位置是否是第一个
        if (position == 0) {
            newNode.next = this.head
            this.head = newNode
        } else {
            // 进行遍历，找到具体的位置，然后插入进去
            let index = 0
            let current = this.head
            let pre = null
            while (index++ < position) {
                pre = current
                current = current.next
            }
            newNode.next = current
            pre.next = newNode
        }
    }

    // get 方法
    LinkedList.prototype.get = function (position) {
        // 首先进行越界判断
        if (position < 0 || position > this.length) return false
        // 2、获取到对应的data
        let current = this.head
        let index = 0
        while (index++ < position) {
            current = current.next
        }
        return current.data
    }

    // indexOf方法
    LinkedList.prototype.indexOf = function (data) {
        // 1、定义变量
        let current = this.head
        let index = 0
        while (current) {
            if (current.data == data) {
                return index
            }
            current = current.next
            index += 1
        }
        // 没有找到就返回 -1
        return -1
    }

    // updata 方法
    LinkedList.prototype.updata = function (position, newData) {

        // 查找正确的节点
        let current = this.head
        let index = 0
        while (index++ < position) {
            current = current.next
        }
        // 将我们position 位置的node的值更改成为 newData
        current.data = newData
    }

    // removeAt(position)方法 
    LinkedList.prototype.removeAt = function (position) {
        // 首先进行越界的判断
        if (position < 0 || position > this.length) return null
        let index = 0
        let current = this.head
        if (position == 0) {
            this.head = this.head.next
        } else {
            let pre = null
            while (index++ < position) { //为了能够找到我们想要的位置 ，就是要删除的那个对象（current）
                pre = current
                current = current.next
            }
            // 让前一个的变成我们当前的下一个
            pre.next = current.next

        }
        // 让我们的总长度减少一个1
        this.length -= 1
        // 返回我们删除的数据
        return current.data
    }
}


// 创建测试代码
var list = new LinkedList()

// 测试append方法
list.append("abc")
list.append("def")
list.append("gop")
// console.log(list);
// 测试我们的toString方法
// console.log(list.toString());

// 测试get方法
// console.log(list.get(1));